home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLINC.PAK / EDIT.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  15KB  |  606 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1991, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.9  $
  6. //
  7. // Definition of class TEdit.  This defines the basic behavior of all edit
  8. // controls.
  9. //----------------------------------------------------------------------------
  10. #if !defined(OWL_EDIT_H)
  11. #define OWL_EDIT_H
  12.  
  13. #if !defined(OWL_STATIC_H)
  14. # include <owl/static.h>
  15. #endif
  16. #include <owl/edit.rh>
  17.  
  18. #if defined(BI_NAMESPACE)
  19. namespace OWL {
  20. #endif
  21.  
  22. class _OWLCLASS TValidator;
  23.  
  24. // Generic definitions/compiler options (eg. alignment) preceeding the
  25. // definition of classes
  26. #include <services/preclass.h>
  27.  
  28. //
  29. // class TEdit
  30. // ~~~~~ ~~~~~
  31. class _OWLCLASS TEdit : public TStatic {
  32.   public:
  33.     TEdit(TWindow*        parent,
  34.           int             id,
  35.           const char far* text,
  36.           int x, int y, int w, int h,
  37.           uint            textLimit = 0,
  38.           bool            multiline = false,
  39.           TModule*        module = 0);
  40.  
  41.     TEdit(TWindow*   parent,
  42.           int        resourceId,
  43.           uint       textLimit = 0,
  44.           TModule*   module = 0);
  45.  
  46.    ~TEdit();
  47.  
  48.     // Accessors
  49.     //
  50.     int     GetNumLines() const;
  51.     int     GetLineLength(int lineNumber) const;
  52.     bool    GetLine(char far* str, int strSize, int lineNumber) const;
  53.     virtual void GetSubText(char far* str, uint startPos, uint endPos) const;
  54.     virtual void GetSelection(uint& startPos, uint& endPos) const;
  55.     virtual uint GetCurrentPosition() const;
  56.  
  57.     bool    IsModified() const;
  58.     void    ClearModify();
  59.  
  60.     int     GetLineFromPos(uint charPos) const;
  61.     uint    GetLineIndex(int lineNumber) const;
  62.  
  63.     uint    Transfer(void* buffer, TTransferDirection direction);
  64.  
  65.     // Lock and unlock this edit control's buffer. Allows direct access to the
  66.     // text in the edit control.
  67.     //
  68.     char far* LockBuffer(uint newSize = 0);
  69.     void    UnlockBuffer(const char far* buffer, bool updateHandle = false);
  70.  
  71.     // Operations
  72.     //
  73.     bool    DeleteSubText(uint startPos, uint endPos);
  74.     bool    DeleteLine(int lineNumber);
  75.     bool    DeleteSelection();
  76.     virtual bool SetSelection(uint startPos, uint endPos);
  77.  
  78.     void    Scroll(int horizontalUnit, int verticalUnit);
  79.  
  80.     void    Insert(const char far* str);
  81.     virtual int Search(uint startPos, const char far* text,
  82.                        bool caseSensitive=false, bool wholeWord=false,
  83.                        bool up=false);
  84.  
  85.     void    GetRect(TRect& frmtRect) const;
  86.     void    SetRect(const TRect& frmtRect);
  87.     void    SetRectNP(const TRect& frmtRect);
  88.     void    FormatLines(bool addEOL);
  89.     void    SetTabStops(int numTabs, const int far* tabs);
  90.     void    LimitText(uint);
  91. #if defined(BI_PLAT_WIN32)
  92.     uint    GetLimitText() const;
  93. #endif
  94.  
  95.     HLOCAL  GetMemHandle() const;
  96.     void    SetMemHandle(HLOCAL localMem);
  97. #if defined(OWL2_COMPAT)
  98.     HLOCAL  GetHandle() const;
  99.     void    SetHandle(HLOCAL localMem);
  100. #endif
  101.  
  102.     void    SetPasswordChar(uint ch);
  103.  
  104.     int     GetFirstVisibleLine() const;
  105.     void    SetReadOnly(bool readOnly);
  106.     uint    GetPasswordChar() const;
  107.  
  108.     EDITWORDBREAKPROC GetWordBreakProc() const;
  109.     void    SetWordBreakProc(EDITWORDBREAKPROC proc);
  110.  
  111.     // Clipboard operations
  112.     //
  113.     bool    CanUndo() const;
  114.     void    EmptyUndoBuffer();
  115.     void    Undo();
  116.     virtual void Paste();
  117.     void    Copy();
  118.     void    Cut();
  119.  
  120.     // Validator functions
  121.     //
  122.     bool    IsValid(bool reportErr = false);
  123.     TValidator*  GetValidator();
  124.     void    SetValidator(TValidator* validator);
  125.     void    ValidatorError();
  126.     bool    IsRefocusing() const;
  127.  
  128. #if defined(BI_PLAT_WIN32)
  129.     // Margin functions
  130.     //
  131.     void    SetLeftMargin(uint16 margin);
  132.     void    SetRightMargin(uint16 margin);
  133.     void    SetMarginUseFontInfo();
  134.     uint32  GetMargins() const;
  135.  
  136.     // Position and character functions
  137.     //
  138.     uint32  CharFromPos(int16 x, int16 y);
  139.     uint32  PosFromChar(uint charIndex);
  140. #endif
  141.  
  142.     // Override TStatic virtual member functions
  143.     //
  144.     void Clear();
  145.  
  146.   protected:
  147.     // Command response functions for edit menu items
  148.     //
  149.     void    CmEditCut();      // CM_EDITCUT
  150.     void    CmEditCopy();     // CM_EDITCOPY
  151.     void    CmEditPaste();    // CM_EDITPASTE
  152.     void    CmEditDelete();   // CM_EDITDELETE
  153.     void    CmEditClear();    // CM_EDITCLEAR
  154.     void    CmEditUndo();     // CM_EDITUNDO
  155.  
  156.     // Command enabler functions for edit menu items
  157.     //
  158.     void CmSelectEnable(TCommandEnabler& commandHandler);
  159.     void CmPasteEnable(TCommandEnabler& commandHandler);
  160.     void CmCharsEnable(TCommandEnabler& commandHandler);
  161.     void CmModEnable(TCommandEnabler& commandHandler);
  162.  
  163.     // Child id notification handled at the child
  164.     //
  165.     void    ENErrSpace();  // EN_ERRSPACE
  166.  
  167.     // Override TWindow virtual member functions
  168.     //
  169.     char far* GetClassName();
  170.     void      SetupWindow();
  171.  
  172.     void         EvChar(uint key, uint repeatCount, uint flags);
  173.     void         EvKeyDown(uint key, uint repeatCount, uint flags);
  174.     uint         EvGetDlgCode(MSG far*);
  175.     void         EvSetFocus(HWND hWndLostFocus);
  176.     void         EvKillFocus(HWND hWndGetFocus);
  177.     bool         CanClose();
  178.  
  179.     // Handler for input validation message sent by parent
  180.     //
  181.     void         EvChildInvalid(HWND);
  182.  
  183.   protected_data:
  184.     // Input validation object
  185.     //
  186.     TValidator*  Validator;
  187.  
  188.   private:
  189.     // Hidden to prevent accidental copying or assignment
  190.     //
  191.     TEdit(const TEdit&);
  192.     TEdit& operator =(const TEdit&);
  193.  
  194.     static TEdit* ValidatorReFocus;
  195.  
  196.   DECLARE_RESPONSE_TABLE(TEdit);
  197.   DECLARE_STREAMABLE(_OWLCLASS, TEdit, 1);
  198. };
  199.  
  200. //
  201. // edit control notification macros. methods are: void method()
  202. //
  203. // EV_EN_CHANGE(id, method)
  204. // EV_EN_ERRSPACE(id, method)
  205. // EV_EN_HSCROLL(id, method)
  206. // EV_EN_KILLFOCUS(id, method)
  207. // EV_EN_MAXTEXT(id, method)
  208. // EV_EN_SETFOCUS(id, method)
  209. // EV_EN_UPDATE(id, method)
  210. // EV_EN_VSCROLL(id, method)
  211.  
  212. // Generic definitions/compiler options (eg. alignment) following the
  213. // definition of classes
  214. #include <services/posclass.h>
  215.  
  216. #if defined(BI_NAMESPACE)
  217. } // namespace OWL
  218. #endif
  219.  
  220. //----------------------------------------------------------------------------
  221. // Inline implementations
  222. //
  223.  
  224. //
  225. inline void TEdit::ClearModify()
  226. {
  227.   PRECONDITION(TWindow::GetHandle());
  228.   SendMessage(EM_SETMODIFY);
  229. }
  230.  
  231. #if defined(OWL2_COMPAT)
  232. //
  233. inline HLOCAL TEdit::GetHandle() const
  234. {
  235.   return GetMemHandle();
  236. }
  237.  
  238. //
  239. inline void TEdit::SetHandle(HLOCAL localMem)
  240. {
  241.   SetMemHandle(localMem);
  242. }
  243. #endif
  244.  
  245. //
  246. inline void TEdit::SetPasswordChar(uint ch)
  247. {
  248.   PRECONDITION(TWindow::GetHandle());
  249.   SendMessage(EM_SETPASSWORDCHAR, ch);
  250. }
  251.  
  252. //
  253. inline void TEdit::EmptyUndoBuffer()
  254. {
  255.   PRECONDITION(TWindow::GetHandle());
  256.   SendMessage(EM_EMPTYUNDOBUFFER);
  257. }
  258.  
  259. //
  260. inline void TEdit::Undo()
  261. {
  262.   PRECONDITION(TWindow::GetHandle());
  263.   SendMessage(WM_UNDO);
  264. }
  265.  
  266. //
  267. inline void TEdit::Paste()
  268. {
  269.   PRECONDITION(TWindow::GetHandle());
  270.   SendMessage(WM_PASTE);
  271. }
  272.  
  273. //
  274. inline void TEdit::Copy()
  275. {
  276.   PRECONDITION(TWindow::GetHandle());
  277.   SendMessage(WM_COPY);
  278. }
  279.  
  280. //
  281. inline void TEdit::Cut()
  282. {
  283.   PRECONDITION(TWindow::GetHandle());
  284.   SendMessage(WM_CUT);
  285. }
  286.  
  287. //
  288. // Return the validator associated with this edit control.
  289. //
  290. inline TValidator* TEdit::GetValidator()
  291. {
  292.   return Validator;
  293. }
  294.  
  295. //
  296. // Return true when this edit control is attempting to regain focus after an
  297. // EvKillFocus with invalid contents
  298. //
  299. inline bool TEdit::IsRefocusing() const
  300. {
  301.   return ValidatorReFocus == this;
  302. }
  303.  
  304. //
  305. inline void TEdit::CmEditCut()
  306. {
  307.   Cut();
  308. }
  309.  
  310. //
  311. inline void TEdit::CmEditCopy()
  312. {
  313.   Copy();
  314. }
  315.  
  316. //
  317. inline void TEdit::CmEditPaste()
  318. {
  319.   Paste();
  320. }
  321.  
  322. //
  323. inline void TEdit::CmEditDelete()
  324. {
  325.   DeleteSelection();
  326. }
  327.  
  328. //
  329. inline void TEdit::CmEditClear()
  330. {
  331.   Clear();
  332. }
  333.  
  334. //
  335. inline void TEdit::CmEditUndo()
  336. {
  337.   Undo();
  338. }
  339.  
  340. //
  341. // Return the number of lines in the associated edit control
  342. //
  343. // Note: return 1 when the edit control has no text (i.e. it has one line
  344. // with no text in it). Return zero if an error occurs
  345. //
  346. inline int TEdit::GetNumLines() const
  347. {
  348.   PRECONDITION(TWindow::GetHandle());
  349.   return (int)CONST_CAST(TEdit*,this)->SendMessage(EM_GETLINECOUNT);
  350. }
  351.  
  352. //
  353. inline bool TEdit::IsModified() const
  354. {
  355.   PRECONDITION(TWindow::GetHandle());
  356.   return (bool)CONST_CAST(TEdit*,this)->SendMessage(EM_GETMODIFY);
  357. }
  358.  
  359. //
  360. // Select the characters in the range "startPos .. endPos"
  361. //
  362. inline bool TEdit::SetSelection(uint startPos, uint endPos)
  363. {
  364.   PRECONDITION(TWindow::GetHandle());
  365. #if defined(BI_PLAT_WIN32)
  366.   return SendMessage(EM_SETSEL, startPos, endPos) != 0;
  367. #else
  368.   return SendMessage(EM_SETSEL, 0, MAKELPARAM(startPos, endPos)) != 0;
  369. #endif
  370. }
  371.  
  372. //
  373. // Return the starting and ending positions of the selected text
  374. //
  375. inline void TEdit::GetSelection(uint& startPos, uint& endPos) const
  376. {
  377.   PRECONDITION(TWindow::GetHandle());
  378. #if defined(BI_PLAT_WIN32)
  379.   CONST_CAST(TEdit*,this)->SendMessage(EM_GETSEL, TParam1(&startPos), TParam2(&endPos));
  380. #else
  381.   TResult  retValue = CONST_CAST(TEdit*,this)->SendMessage(EM_GETSEL);
  382.   startPos = LoUint16(retValue);
  383.   endPos   = HiUint16(retValue);
  384. #endif
  385. }
  386.  
  387.  
  388. //
  389. // Return the current caret position.
  390. //
  391. inline uint TEdit::GetCurrentPosition() const
  392. {
  393.   PRECONDITION(TWindow::GetHandle());
  394.   uint CurPos = 0;
  395.   GetSelection(CurPos, CurPos);
  396.   return CurPos;
  397. }
  398.  
  399.  
  400. //
  401. // Return the line number associated with character index "CharPos"
  402. //
  403. // If "CharPos" is greater than the number of characters, the last line is
  404. // returned
  405. // If "CharPos" is -1, the line containing the beginning of the selection (or
  406. // the line containing the caret if no selection) is returned
  407. //
  408. inline int TEdit::GetLineFromPos(uint charPos) const
  409. {
  410.   PRECONDITION(TWindow::GetHandle());
  411.   return (int)CONST_CAST(TEdit*,this)->SendMessage(EM_LINEFROMCHAR, charPos);
  412. }
  413.  
  414. //
  415. // Return the character index of line number "LineNumber" or -1 if
  416. // "LineNumber" is greater than the number of lines
  417. //
  418. // If "LineNumber" is -1, the line containing the caret is used
  419. //
  420. inline uint TEdit::GetLineIndex(int lineNumber) const
  421. {
  422.   PRECONDITION(TWindow::GetHandle());
  423.   return (int)CONST_CAST(TEdit*,this)->SendMessage(EM_LINEINDEX, lineNumber);
  424. }
  425.  
  426. //
  427. // Scroll the text by the specified horizontal and vertical amounts
  428. //
  429. inline void TEdit::Scroll(int horizUnit, int vertUnit)
  430. {
  431.   PRECONDITION(TWindow::GetHandle());
  432. #if defined(BI_PLAT_WIN32)
  433.   SendMessage(EM_LINESCROLL, horizUnit, vertUnit);
  434. #else
  435.   SendMessage(EM_LINESCROLL, 0, MAKELONG(vertUnit, horizUnit));
  436. #endif
  437. }
  438.  
  439. //
  440. // Sets the selection to the "str" (does a "paste" type of action without
  441. // affecting the clipboard)
  442. //
  443. inline void TEdit::Insert(const char far* str)
  444. {
  445.   PRECONDITION(TWindow::GetHandle());
  446.   SendMessage(EM_REPLACESEL, 0, TParam2(str));
  447. }
  448.  
  449. //
  450. inline void TEdit::GetRect(TRect& frmtRect) const
  451. {
  452.   PRECONDITION(TWindow::GetHandle());
  453.   CONST_CAST(TEdit*,this)->SendMessage(EM_GETRECT, 0, TParam2((TRect FAR*)&frmtRect));
  454. }
  455.  
  456. //
  457. inline void TEdit::SetRect(const TRect& frmtRect)
  458. {
  459.   PRECONDITION(TWindow::GetHandle());
  460.   SendMessage(EM_SETRECT, 0, TParam2((const TRect FAR*)&frmtRect));
  461. }
  462.  
  463. //
  464. inline void TEdit::SetRectNP(const TRect& frmtRect)
  465. {
  466.   PRECONDITION(TWindow::GetHandle());
  467.   SendMessage(EM_SETRECTNP, 0, TParam2((const TRect FAR*)&frmtRect));
  468. }
  469.  
  470. //
  471. inline void TEdit::FormatLines(bool addEOL)
  472. {
  473.   PRECONDITION(TWindow::GetHandle());
  474.   SendMessage(EM_FMTLINES, addEOL);
  475. }
  476.  
  477. //
  478. inline void TEdit::SetTabStops(int numTabs, const int far* tabs)
  479. {
  480.   PRECONDITION(TWindow::GetHandle());
  481.   SendMessage(EM_SETTABSTOPS, numTabs, TParam2(tabs));
  482. }
  483.  
  484. //
  485. // Limit the amount of new text that can be entered in the edit control.
  486. //
  487. inline void TEdit::LimitText(uint txtLen)
  488. {
  489.   PRECONDITION(TWindow::GetHandle());
  490.   SendMessage(EM_LIMITTEXT, TParam1(txtLen));
  491. }
  492.  
  493. //
  494. // Return the memory handle for the edit control's buffer.
  495. //
  496. inline HLOCAL TEdit::GetMemHandle() const
  497. {
  498.   PRECONDITION(TWindow::GetHandle());
  499.   return (HLOCAL)CONST_CAST(TEdit*,this)->SendMessage(EM_GETHANDLE);
  500. }
  501.  
  502. //
  503. // Sets the memory handle for the edit control's buffer.
  504. //
  505. inline void TEdit::SetMemHandle(HLOCAL localMem)
  506. {
  507.   PRECONDITION(TWindow::GetHandle());
  508.   SendMessage(EM_SETHANDLE, TParam1(localMem));
  509. }
  510.  
  511. //
  512. inline int TEdit::GetFirstVisibleLine() const
  513. {
  514.   PRECONDITION(TWindow::GetHandle());
  515.   return (int)CONST_CAST(TEdit*,this)->SendMessage(EM_GETFIRSTVISIBLELINE);
  516. }
  517.  
  518. //
  519. inline void TEdit::SetReadOnly(bool readOnly)
  520. {
  521.   PRECONDITION(TWindow::GetHandle());
  522.   SendMessage(EM_SETREADONLY, readOnly);
  523. }
  524.  
  525. //
  526. inline uint TEdit::GetPasswordChar() const
  527. {
  528.   PRECONDITION(TWindow::GetHandle());
  529.   return (uint)CONST_CAST(TEdit*,this)->SendMessage(EM_GETPASSWORDCHAR);
  530. }
  531.  
  532. //
  533. inline EDITWORDBREAKPROC TEdit::GetWordBreakProc() const
  534. {
  535.   PRECONDITION(TWindow::GetHandle());
  536.   return (EDITWORDBREAKPROC)CONST_CAST(TEdit*,this)->SendMessage(EM_GETWORDBREAKPROC);
  537. }
  538.  
  539. //
  540. inline void TEdit::SetWordBreakProc(EDITWORDBREAKPROC proc)
  541. {
  542.   PRECONDITION(TWindow::GetHandle());
  543.   SendMessage(EM_SETWORDBREAKPROC, 0, TParam2(proc));
  544. }
  545.  
  546. //
  547. inline bool TEdit::CanUndo() const
  548. {
  549.   PRECONDITION(TWindow::GetHandle());
  550.   return (bool)CONST_CAST(TEdit*,this)->SendMessage(EM_CANUNDO);
  551. }
  552.  
  553. #if defined(BI_PLAT_WIN32)
  554. //
  555. inline void TEdit::SetLeftMargin(uint16 margin)
  556. {
  557.   PRECONDITION(TWindow::GetHandle());
  558.   SendMessage(EM_SETMARGINS, EC_LEFTMARGIN, MkUint32(0, margin));
  559. }
  560.  
  561. //
  562. inline void TEdit::SetRightMargin(uint16 margin)
  563. {
  564.   PRECONDITION(TWindow::GetHandle());
  565.   SendMessage(EM_SETMARGINS, EC_RIGHTMARGIN, MkUint32(margin, 0));
  566. }
  567.  
  568. //
  569. inline void TEdit::SetMarginUseFontInfo()
  570. {
  571.   PRECONDITION(TWindow::GetHandle());
  572.   SendMessage(EM_SETMARGINS, EC_USEFONTINFO, 0);
  573. }
  574.  
  575. //
  576. inline uint32 TEdit::GetMargins() const
  577. {
  578.   PRECONDITION(TWindow::GetHandle());
  579.   return (uint32)CONST_CAST(TEdit*,this)->SendMessage(EM_GETMARGINS);
  580. }
  581.  
  582. //
  583. inline uint TEdit::GetLimitText() const
  584. {
  585.   PRECONDITION(TWindow::GetHandle());
  586.   return (uint)CONST_CAST(TEdit*,this)->SendMessage(EM_GETLIMITTEXT);
  587. }
  588.  
  589. //
  590. inline uint32 TEdit::CharFromPos(int16 x, int16 y) {
  591.   PRECONDITION(TWindow::GetHandle());
  592.   // y is the high-order word of lParam
  593.   // x is the low-order word of lParam
  594.   //
  595.   return (uint32)SendMessage(EM_CHARFROMPOS, 0, MkUint32(y, x));
  596. }
  597.  
  598. //
  599. inline uint32 TEdit::PosFromChar(uint charIndex) {
  600.   PRECONDITION(TWindow::GetHandle());
  601.   return (uint32)SendMessage(EM_POSFROMCHAR, charIndex);
  602. }
  603. #endif  // BI_PLAT_WIN32
  604.  
  605. #endif  // OWL_EDIT_H
  606.